home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / ggraph / RCS / set.c,v < prev    next >
Text File  |  1990-07-07  |  11KB  |  393 lines
  1. head     1.2;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.2
  10. date     90.07.07.15.29.02;  author eklee;  state Exp;
  11. branches ;
  12. next     1.1;
  13.  
  14. 1.1
  15. date     89.07.12.01.41.00;  author douglis;  state Exp;
  16. branches ;
  17. next     ;
  18.  
  19.  
  20. desc
  21. @baseline from monet (?)
  22. @
  23.  
  24.  
  25. 1.2
  26. log
  27. @Added braces that were left out by the author.
  28. @
  29. text
  30. @#include <stdio.h>
  31. #include <errno.h>
  32. #include <strings.h>
  33. #include <math.h>
  34. #include "ggraph.h"
  35. #include "ggraphdefs.h"
  36.  
  37. /* set any unset defaults for lines */
  38. setdefault () {
  39.     register int    i;
  40.     for (curline = 0; ((curline != cg.maxlines) && (cl != NULL)); ++curline) {
  41.     if (!cl->llabsw)
  42.         cl->llabsw = FALSE;
  43.     if (cl->mtype == -1)
  44.         cl->mtype = CROSS;
  45.     if (cl->ltype == -1)
  46.         cl->ltype = BRUSH_NORMAL;
  47.     if (cl->ctype == -1)
  48.         cl->ctype = LINE;
  49.     if(cl->llabel.t_size == -1)
  50.         cl->llabel.t_size = 2;
  51.     if(cl->llabel.t_font == -1)
  52.         cl->llabel.t_font = ROMAN;
  53.     if(cl->llelabel.t_size == -1)
  54.         cl->llelabel.t_size = 2;
  55.     if(cl->llelabel.t_font == -1)
  56.         cl->llelabel.t_font = ROMAN;
  57.     }
  58.     if (cg.gtype == -1)
  59.     cg.gtype = LINEAR;
  60.     if (cg.xpreci1 == -1)
  61.     cg.xpreci1 = 4;
  62.     if (cg.ypreci1 == -1)
  63.     cg.ypreci1 = 4;
  64.     if (cg.symbolsz == -1)
  65.     cg.symbolsz = 3.0;
  66.     if (cg.logxsw == -1)
  67.     cg.logxsw = 0;
  68.     if (cg.logxtick == -1)
  69.     cg.logxtick = 10.0;
  70.     if (cg.logysw == -1)
  71.     cg.logysw = 0;
  72.     if (cg.logytick == -1)
  73.     cg.logytick = 10.0;
  74.     if (cg.gframe.fsize == -1)
  75.     cg.gframe.fsize = BRUSH_THIN;
  76.     if (cg.lframe.fsize == -1)
  77.     cg.lframe.fsize = BRUSH_THIN;
  78.     if (cg.lframe.fsize == -1)
  79.     cg.lframe.fsize = BRUSH_THIN;
  80.     if (cg.gtitle.t_size == -1)
  81.     cg.gtitle.t_size = 3;
  82.     if (cg.xtick.t_size == -1)
  83.     cg.xtick.t_size = 2;
  84.     if (cg.ytick.t_size == -1)
  85.     cg.ytick.t_size = 2;
  86.     if (cg.xlabel.t_size == -1)
  87.     cg.xlabel.t_size = 2;
  88.     if (cg.ylabel.t_size == -1)
  89.     cg.ylabel.t_size = 2;
  90.     if (cg.legend.t_size == -1)
  91.     cg.legend.t_size = 2;
  92.     if (cg.yvert == -1)
  93.     cg.yvert = 1;
  94.     if (cg.gtitle.t_font == -1)
  95.     cg.gtitle.t_font = ROMAN;
  96.     if (cg.legend.t_font == -1)
  97.     cg.legend.t_font = ROMAN;
  98.     if (cg.xlabel.t_font == -1)
  99.     cg.xlabel.t_font = ROMAN;
  100.     if (cg.ylabel.t_font == -1)
  101.     cg.ylabel.t_font = ROMAN;
  102.     if (cg.xtick.t_font == -1)
  103.     cg.xtick.t_font = ROMAN;
  104.     if (cg.ytick.t_font == -1)
  105.     cg.ytick.t_font = ROMAN;
  106.     if (cg.xgrid_type == -1)
  107.     cg.xgrid_type = BRUSH_DOT;
  108.     if (cg.ygrid_type == -1)
  109.     cg.ygrid_type = BRUSH_DOT;
  110.     if (cg.firstxsw == -1)
  111.     cg.firstxsw = 0;
  112.     if (cg.firstysw == -1)
  113.     cg.firstysw = 0;
  114.     if(legendf){
  115.       calc_legend(&cg.xplotmax,&cg.yorigin);    /* figure out lengend stuff */
  116.       cg.yplotmax = YPLOTMAX;
  117.     }else{
  118.       cg.xplotmax = XPLOTMAX;
  119.       cg.yplotmax = YPLOTMAX;
  120.     }
  121.     cg.gframe.frame1x = FRAME1X;    /* set frame boundaries */
  122.     cg.gframe.frame2x = FRAME2X;
  123.     cg.gframe.frame3x = FRAME3X;
  124.     cg.gframe.frame4x = FRAME4X;
  125.     cg.gframe.frame1y = FRAME1Y;
  126.     cg.gframe.frame2y = FRAME2Y;
  127.     cg.gframe.frame3y = FRAME3Y;
  128.     cg.gframe.frame4y = FRAME4Y;
  129. }
  130. /* set the axis limits and centers */
  131. setlim () {
  132.     float   xrange,
  133.             yrange;        /* range along each axis */
  134.     float   xtestr,
  135.             ytestr;        /* range along each axis to test */
  136.     register int    n,
  137.                     factor;
  138.     int     axmax;
  139.     double  pow ();
  140.  
  141.     n = 0;
  142.     if ((cg.dtickx == 0) || (cg.logxsw == 1)) {
  143.     xrange = cg.gmaxx - cg.gminx;
  144.     if (xrange < 1.0)
  145.         factor = -1;
  146.     else
  147.         factor = 1;
  148.     if (factor == 1) {
  149.         while (TRUE) {
  150.         xtestr = pow ((double) 10.0, (double) n);
  151.         if ((xrange / xtestr) < 1.0)
  152.             break;
  153.         n = n + factor;
  154.         }
  155.     }
  156.     else {
  157.         while (TRUE) {
  158.         xtestr = pow ((double) 10.0, (double) n);
  159.         if ((xrange / xtestr) > 1.0) {
  160.             factor = 0;
  161.             break;
  162.         }
  163.         n = n + factor;
  164.         }
  165.         if (cg.xpreci2 == -1)
  166.         cg.xpreci2 = -n + 1;
  167.     }
  168.     cg.dtickx = pow ((double) 10.0, (double) (n - factor));
  169.     axmax = xrange / cg.dtickx;
  170.     if (cg.logxsw) {
  171. if(debug)printf("xmaxtic %d %f\n", cg.maxtickx, cg.stickx);
  172.         if (cg.maxtickx == 0)
  173.         cg.maxtickx = (int) ((log10 ((double) cg.gmaxx) /
  174.                 log10 ((double) cg.logxtick)));
  175.         if (cg.stickx != 0)
  176.         cg.mintickx = cg.xoffset = (int)(log10((double)cg.stickx) /
  177.             log10 ((double) (cg.logxtick)));
  178.         else {
  179.         cg.mintickx = cg.xoffset = (int)(log10((double)cg.gminx) /
  180.             log10 ((double) (cg.logxtick)));
  181.         }
  182.         if (debug){
  183.         printf ("decide1 %f %f\n", cg.gminx, (cg.gmaxx -
  184.                 pow ((double) cg.logxtick, (double) cg.maxtickx)));
  185.         printf ("decide2 %f %f\n", cg.gmaxx, (cg.gminx -
  186.                 pow ((double) cg.logxtick, (double) cg.mintickx)));
  187.         printf ("decide3 %f %f\n", cg.gmaxx, (cg.gminx -
  188.                 (float)pow ((double) cg.logxtick, (double) cg.mintickx)));
  189.         printf ("decide4 %f %f\n", cg.gmaxx, ((double)cg.gminx -
  190.                 pow ((double) cg.logxtick, (double) cg.mintickx)));
  191.         }
  192.         if ((cg.gmaxx - pow ((double) cg.logxtick, (double) cg.maxtickx))
  193.             > 0.0)
  194.         cg.maxtickx++;
  195.         if (cg.stickx == 0.0)
  196.         if ((cg.gminx - (float) pow ((double) cg.logxtick, (double) cg.mintickx))
  197.             < 0.0) {
  198.             cg.mintickx--;
  199.             cg.xoffset--;
  200.         }
  201.         if (!cg.numtickx)
  202.         cg.numtickx = abs ((int) cg.maxtickx - (int) cg.mintickx);
  203.         cg.xoffset = (int) cg.xoffset;
  204.         if (debug)
  205.         printf ("maxt %d mint %d numt %d off %f\n",
  206.           cg.maxtickx, cg.mintickx, cg.numtickx, cg.xoffset);
  207.     }else{
  208.         if (!cg.numtickx)
  209.           if((axmax * cg.dtickx) < xrange)
  210.         cg.numtickx = axmax + 1;
  211.           else
  212.         cg.numtickx = axmax;
  213.           if (!cg.stickx)
  214.         cg.stickx = cg.gminx;
  215.           cg.xoffset = cg.gminx;
  216.     }
  217.     }else
  218.       cg.xoffset = cg.stickx;
  219.     n = 0;
  220.     if ((cg.dticky == 0) || (cg.logysw == 1)) {
  221.     yrange = cg.gmaxy - cg.gminy;
  222.     if (yrange < 1.0)
  223.         factor = -1;
  224.     else
  225.         factor = 1;
  226.     if (factor == 1) {
  227.         while (TRUE) {
  228.         ytestr = pow ((double) 10.0, (double) n);
  229.         if ((yrange / ytestr) < 1.0)
  230.             break;
  231.         n = n + factor;
  232.         }
  233.     }
  234.     else {
  235.         while (TRUE) {
  236.         ytestr = pow ((double) 10.0, (double) n);
  237.         if ((yrange / ytestr) > 1.0) {
  238.             factor = 0;
  239.             break;
  240.         }
  241.         n = n + factor;
  242.         }
  243.         if (cg.ypreci2 == -1)
  244.         cg.ypreci2 = -n + 1;
  245.     }
  246.     cg.dticky = pow ((double) 10.0, (double) (n - factor));
  247.     axmax = yrange / cg.dticky;
  248.     if (cg.logysw) {
  249.         if (cg.maxticky == 0)
  250.         cg.maxticky = (int) ((log10 ((double) cg.gmaxy) /
  251.                 log10 ((double) cg.logytick)));
  252.         if (cg.sticky != 0)
  253.         cg.minticky = cg.yoffset = (int) ((log10 ((double) cg.sticky) /
  254.                 log10 ((double) (cg.logytick))));
  255.         else {
  256.         cg.minticky = cg.yoffset = (int) ((log10 ((double) cg.gminy) /
  257.                 log10 ((double) (cg.logytick))));
  258.         }
  259.         if ((cg.gmaxy - pow ((double) cg.logytick, (double) cg.maxticky))
  260.             > 0.0)
  261.         cg.maxticky++;
  262.         if (debug)
  263.         printf ("decide %f %f\n", cg.gminy, (cg.gminy -
  264.                 pow ((double) cg.logytick, (double) cg.minticky)));
  265.         if (cg.sticky == 0.0)
  266.         if ((cg.gminy - (float) pow ((double) cg.logytick, (double) cg.minticky))
  267.             < 0.0) {
  268.             cg.minticky--;
  269.             cg.yoffset--;
  270.         }
  271.         if (!cg.numticky)
  272.         cg.numticky = abs ((int) cg.maxticky - (int) cg.minticky);
  273.         cg.yoffset = (int) cg.yoffset;
  274.         if (debug)
  275.         printf ("maxt %d mint %d numt %d\n", cg.maxticky, cg.minticky,
  276.             cg.numticky);
  277.     }else{
  278.         if (!cg.numticky)
  279.           if((axmax * cg.dticky) < yrange)
  280.         cg.numticky = axmax + 1;
  281.           else
  282.         cg.numticky = axmax;
  283.           if (!cg.sticky)
  284.         cg.sticky = cg.gminy;
  285.           cg.yoffset = cg.gminy;
  286.     }
  287.     }else
  288.       cg.yoffset = cg.sticky;
  289.     if ((cg.numtickx) < 3 && !cg.logxsw) {
  290.     cg.numtickx = cg.numtickx * 2;
  291.     cg.dtickx = cg.dtickx / 2.0;
  292.     if((cg.dtickx < 1.0)&&(cg.xpreci2 == -1)) {
  293.        cg.xpreci1 = 1;
  294.        cg.xpreci2 = 1;
  295.     }
  296.     }
  297.     if ((cg.numticky < 3) && !cg.logysw) {
  298.     cg.numticky = cg.numticky * 2;
  299.     cg.dticky = cg.dticky / 2.0;
  300.     if((cg.dticky < 1.0)&&(cg.ypreci2 == -1)){
  301.        cg.ypreci1 = 1;
  302.        cg.ypreci2 = 1;
  303.     }
  304.     }
  305. /* to calculate scale -> PLOTMAX - origin > scale*maxtick*dtick */
  306. /* therefore scale = (PLOTMAX - origin)/(maxtick*dtick) */
  307.  /* center is in user units */
  308.     cg.xcenter = (cg.numtickx * cg.dtickx) / 2.0;
  309.     cg.ycenter = (cg.numticky * cg.dticky) / 2.0;
  310.     calc_text(&cg.xorigin, &cg.yorigin);
  311.     if(debug)printf("origins from text %f %f\n", cg.xorigin, cg.yorigin);
  312.     if(debug)printf("X Label %f %f\n", cg.xlabel.t_xpos, cg.xlabel.t_ypos);
  313.     if(debug)printf("Y Label %f %f\n", cg.ylabel.t_xpos, cg.ylabel.t_ypos);
  314.  /* set scale factors */
  315.     cg.scalex = (cg.xplotmax - cg.xorigin) / (cg.numtickx * cg.dtickx);
  316.     cg.scaley = (cg.yplotmax - cg.yorigin) / (cg.numticky * cg.dticky);
  317.     if (debug)
  318.     fprintf (stderr, "dtickx %f maxtick %d stickx %f\n\
  319.  numtick %d scale %f center %f offset %f\n",
  320.         cg.dtickx, cg.maxtickx, cg.stickx, cg.numtickx, 
  321.         cg.scalex, cg.xcenter, cg.xoffset);
  322.     if (debug)
  323.     fprintf (stderr, "dticky %f maxtick %d sticky %f\n\
  324.  numtick %d scale %f center %f offset %f\n",
  325.         cg.dticky, cg.maxticky, cg.sticky, cg.numticky,
  326.         cg.scaley, cg.ycenter, cg.yoffset);
  327.  
  328.  /* title is in device units since it's */
  329.  /* only used once might as well do it here */
  330.  /*    cg.gtitle.t_xpos = (cg.xcenter * cg.scalex) + cg.xorigin - 
  331.     ((cg.xorigin - cg.gframe.frame1x)/2);*/
  332.     if(!cg.gtitle.t_xpos)
  333.         cg.gtitle.t_xpos = ((cg.gframe.frame3x - cg.gframe.frame1x)/2) + 
  334.     cg.gframe.frame1x;
  335.     if(!cg.gtitle.t_ypos)
  336.         cg.gtitle.t_ypos = (cg.numticky * cg.dticky * cg.scaley)
  337.      + cg.yorigin + 25;
  338.     return;
  339. }
  340.  
  341. calc_text(xo, yo)
  342. float *xo, *yo;    /* coords to set */
  343. {
  344.     register int i;
  345.     float textx, texty, height;    /* for computing vertical text */
  346.     char numstr[10];
  347.  
  348.     if (!*xo){
  349.     if(cg.ypreci2 == -1){
  350.         sprintf(numstr, "%d", (int)cg.gmaxy);
  351.         i = strlen(numstr);
  352.     }else
  353.         i = cg.ypreci1 + cg.ypreci2;
  354.     *xo = cg.gframe.frame1x + ycharsz[cg.ylabel.t_size] + /* set origins */
  355.         i * ycharsz[cg.ytick.t_size];
  356.     }
  357.     if (!*yo)
  358.     *yo = cg.gframe.frame1y + (3.0 * ycharsz[cg.xlabel.t_size]);
  359.     if(!cg.xlabel.t_xpos)
  360.       cg.xlabel.t_xpos = (cg.xplotmax - *xo)/2 + *xo;
  361.     if(!cg.xlabel.t_ypos)
  362.       cg.xlabel.t_ypos = *yo - (1.75 * ycharsz[cg.xlabel.t_size]);
  363.     if(!cg.yvert){
  364.     if(!cg.ylabel.t_xpos)
  365.       cg.ylabel.t_xpos = cg.gframe.frame1x+(2*ycharsz[cg.ylabel.t_size]);
  366.     if(!cg.ylabel.t_ypos)
  367.       cg.ylabel.t_ypos = cg.ycenter;
  368.     }else{
  369.     i = strlen(cg.ylabel.t_text) * ycharsz[cg.ylabel.t_size]; /* get length */
  370.     height = YPLOTMAX-*yo;
  371.     texty = *yo + height - ((height - (float)i)/2.0);
  372.     if(!cg.ylabel.t_xpos)
  373.       cg.ylabel.t_xpos = cg.gframe.frame1x+ycharsz[cg.ylabel.t_size];
  374.     if(!cg.ylabel.t_ypos)
  375.       cg.ylabel.t_ypos = texty;
  376.     }
  377.     if (debug)
  378.     fprintf (stderr, "orgs %f %f\n", *xo, *yo);
  379. }
  380. @
  381.  
  382.  
  383. 1.1
  384. log
  385. @Initial revision
  386. @
  387. text
  388. @d263 1
  389. a263 1
  390.     if((cg.dtickx < 1.0)&&(cg.xpreci2 == -1))
  391. d266 1
  392. @
  393.